Authenticate User

This example demonstrates how to authenticate users for the main application.

using System;
using System.Linq;
using System.Web;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

namespace CsWebSite
{
	public partial class Default : System.Web.UI.Page
	{
		public const String API_PATH = "http://mySite.com/API3/";
		protected void Page_Load(object sender, EventArgs e)
		{
			//logging the user
			String adminToken = getToken("authenticateUser", new
			{ 	
				userName = "adminUser1",
				password = "abc123!"
			});

			String userToken = getToken("authenticateUserByToken", new
			{ 	
				userIdentity = "userName",
				token = adminToken
			});
			//this cookie should be placed on the domain pyramid is installed on - mySite.com in this example
			Response.Cookies.Add(new HttpCookie("PyramidAuth", userToken));


		}

	//generic method for getting the token via REST
		private String getToken(String service, Object data)
		{
			HttpClient client = new HttpClient();

			StringContent content = null;
			content = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
			Task<HttpResponseMessage> response = client.PostAsync(API_PATH + "authentication/" + service, content);

			return response.Result.Content.ReadAsStringAsync().Result;
		}
		

	}
}

		

This example demonstrates how to authenticate users for the main application.

import com.sun.net.httpserver.HttpExchange;
import com.sun.net.httpserver.HttpHandler;
import com.sun.net.httpserver.HttpServer;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.BasicResponseHandler;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.json.simple.JSONObject;

import java.io.IOException;
import java.net.InetSocketAddress;

public class Main {
	private static final String pyramidPath = "http://mySite.com/API3/";

	public static void main(String[] args) throws IOException {
		HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
		server.createContext("/login", new LoginHandler());


		server.setExecutor(null); // creates a default executor
		server.start();

	}

	private static class LoginHandler implements HttpHandler {
		@Override
		public void handle(HttpExchange httpExchange) throws IOException {
			//logging the user
			JSONObject adminCredentials = new JSONObject();
			adminCredentials.put("userName", "testUser1");
			adminCredentials.put("password", "abc456!");
			String adminToken = getToken("authenticateUser", adminCredentials);

			//logging the user in using the admin's token
			JSONObject userCredentials = new JSONObject();
			userCredentials.put("userIdentity", "test.user1@mySite.com");
			userCredentials.put("token", adminToken);

			String userToken = getToken("authenticateUserByToken", userCredentials);

			//searching the user by name 
			JSONObject results = callApi("access/getUsersByName", "testUser1", adminToken);
			String userId = ((JSONObject) ((JSONArray) results.get("data")).get(0)).get("id").toString();

			//reading the user's private folder
			JSONObject privateFolder = callApi("content/getFolderItems", 
				userId,//the user private folder id is the same as the user id
				adminToken
			);
			String messageStr = "private folder id is " + userId + " and it contains ";
			JSONArray folderContent = ((JSONArray) privateFolder.get("data"));
			for (int i = 0; i < folderContent.size(); ++i) {
				messageStr += ((JSONObject) folderContent.get(i)).get("caption") + ",";
			}

			byte[] message = messageStr.getBytes(StandardCharsets.UTF_8);
			httpExchange.getResponseHeaders().add("Set-Cookie", "PyramidAuth=" + userToken);
			httpExchange.sendResponseHeaders(200, message.length);
			httpExchange.getResponseBody().write(message);
		}
	}


	protected static String getToken(String service, JSONObject data) throws IOException {
		return sendPost("authentication/" + service, data.toJSONString(),null);
	}


	protected static String sendPost(String path, String data, String token) throws IOException {
		try (CloseableHttpClient httpClient = HttpClientBuilder.create().build()) {

			String address = pyramidPath + path;
			HttpPost request = new HttpPost(address);
			StringEntity params = new StringEntity(data);
			request.addHeader("content-type", "application/x-www-form-urlencoded");
			if (token !=null) {
				request.addHeader("paToken", token);
			}
			request.setEntity(params);
			CloseableHttpResponse response = httpClient.execute(request);
			return new BasicResponseHandler().handleResponse(response);
		}
	}
}


		

This example demonstrates how to authenticate a user from JavaScript.

// URL of the Pyramid installation and the path to the API 3.0 REST methods
var pyramidURL = "http://mysite.com/api3/";

// step 1: authenticate user account and get token
// NOTE: callApi method is a generic REST method shown below.
let token = callApi("authentication/authenticateUser",{
	"userName":"aUser",
	"password":"abc123!"
},"",false);
log("got token "+token);

// step 2: get the current user's ID
let currentUser= callApi("access/getMe",
	{},token
);

// step3: get the user's ID from the response
let userId = currentUser[0];




// ##### optional generic login method for debugging ##############
function log(msg){
	document.write(msg);
	console.log(msg);
}

// ##### generic REST API calling method ##############
function callApi(path,data,token="",parseResult=true){
	var xhttp = new XMLHttpRequest();
	xhttp.open("POST", pyramidURL+path, false);
	xhttp.setRequestHeader("paToken",token)
	xhttp.send(JSON.stringify(data));
	if(parseResult){
		return JSON.parse(xhttp.responseText);
	}else{
		return xhttp.responseText;
	}
}


		

This example demonstrates how to get model structure create custom furmula and list and use it to create discover.

using System;
using PyramidAnalytics.Sdk.Api;
using PyramidAnalytics.Sdk.Client;
using PyramidAnalytics.Sdk.Model;

Main();
static void Main()
{
    // base configurations
    Configuration conf = new Configuration();
    conf.BasePath = "http://mysite.com";

    //authenticate user - returns the authentication Token
    AuthenticationServiceApi api = new AuthenticationServiceApi(conf);
    string token = api.AuthenticateUser(new UserCredentials(
		username: "adminUser",
		password: "abc123!"
		));
    Console.WriteLine("Api token : " + token);

    // set token for further APIs
    conf.AddApiKey("paToken", token);
    GlobalConfiguration.Instance = conf;

    // find folder to save
    ContentServiceApi contentApi = new ContentServiceApi();
    Guid folderId = getFolder(contentApi, "FolderName");

    //initialize the datasources api
    DataSourcesServiceApi dataSourcesApi = new DataSourcesServiceApi();

    //get the connection string for the model
    ConnectionSearchCriteria cssc = new ConnectionSearchCriteria(
        serverSearchCriteria: new SearchCriteria(
            searchValue: "In-Memory DB",
            searchMatchType: SearchMatchType.Equals
            ),
        databaseSearchCriteria: new SearchCriteria(
            searchValue: "SampleDemo",
            searchMatchType: SearchMatchType.Equals
            ),
        modelSearchCriteria: new SearchCriteria(
            searchValue: "SampleDemo",
            searchMatchType: SearchMatchType.Contains
            )
        );
    Guid connectionStringId = Guid.Parse(dataSourcesApi.FindModelConnection(cssc)[0].Id);
    Console.WriteLine("Connection String Id : " + connectionStringId);

    //find theme
    ThemesServiceApi themesApi = new ThemesServiceApi();
    string themeId = themesApi.FindThemeByName(new SearchCriteria(searchValue: "Pyramid", searchMatchType: SearchMatchType.Contains))[0].ThemeId;
    Console.WriteLine("Theme Id : " + themeId);

    //get the model definition
    ModelingModel mom = dataSourcesApi.GetModelStructure(connectionStringId.ToString());

    // create custom list and formula
    AnalyticsServiceApi analystApi = new AnalyticsServiceApi();
    Guid listId = addList(analystApi, connectionStringId, folderId, mom);
    Guid formulaId = addFormula(analystApi, connectionStringId, folderId, mom);

    // create discovery
    addDiscovery(analystApi, connectionStringId, folderId, formulaId, listId, themeId, mom);
}

// find folder from user private folder with specific name
static Guid getFolder(ContentServiceApi contentApi, string folderName)
{
    ContentSearchParamsObject searchParams = new ContentSearchParamsObject(
        searchString: folderName,
        filterTypes: new List<ContentTypeObject> { ContentTypeObject.Folder },
        searchMatchType: SearchMatchType.Equals,
        searchRootFolderType: SearchRootFolderType.Private
        );

    List<PyramidContentItem> folders = contentApi.FindContentItem(searchParams);
    Guid folderId = Guid.Parse(folders[0].Id);
    Console.WriteLine("Folder id : " + folderId);
    return folderId;
}

// create custom list for the product.color hierarchy to filter 2 values from it's members
static Guid addList(AnalyticsServiceApi analystApi, Guid connectionStringId, Guid folderId, ModelingModel mom)
{
    // get unique name from the model
    String uniqueName = getColumnUniqueNameFromModel(mom, "products", "Color");
    // create the formula for exclusion of specific members
    String formulaSyntax = String.Format("{{Except({{AllMembers({0})}},{{{0}.[Multi],{0}.[NA]}})}}", uniqueName);
    ListData customList = new ListData(connectionId: connectionStringId,
                    formulaSyntax: formulaSyntax,
                    itemName: "All Colors without NA and Multi",
                    description: "custom list item descriptions",
                    folderId: folderId,
                    parentDimension: "[products]", // parent table
                    parentHierarchy: uniqueName // parent hierarchy
                    );

    Guid listId = analystApi.SetList(customList);// create list
    Console.WriteLine("List id : " + listId);
    return listId;
}

// create custom measure formula to calculate the price per quantity
static Guid addFormula(AnalyticsServiceApi analystApi, Guid connectionStringId, Guid folderId, ModelingModel mom)
{
    // get unique names from the model
    var price = getMeasureUniqueNameFromModel(mom, "data", "price");
    var quantity = getMeasureUniqueNameFromModel(mom, "data", "quantity");

    FormulaData customFormula = new FormulaData(connectionId: connectionStringId,
                    formulaSyntax: price + "/" + quantity, // formula: "[measures].[data Price]/[measures].[data Quantity]"
                    itemName: "Price By Quantity",
                    folderId: folderId,
                    parentDimension: "[measures]" // global measures
                    );

    Guid formulaId = analystApi.SetFormula(customFormula);// create formula
    Console.WriteLine("Formula id : " + formulaId);
    return formulaId;
}

static void addDiscovery(AnalyticsServiceApi analystApi, Guid connectionStringId, Guid folderId, Guid formulaId, Guid listId, string themeId, ModelingModel mom)
{
    DiscoverData simpleDiscovery = new DiscoverData(connectionId: connectionStringId,
                    itemName: "Prices by categories",
                    description: "Discovery item descriptions",
                    folderId: folderId,
                    themeId: themeId,
                    visuals: new Visuals(cartesian:// create cartesian visual
                        new CartesianVisual(
                            visualType: CartesianVisualType.StackedColumnChart, // Chart type: StackedColumnChart
                            categories: new CartesianCategoriesDropZone(new List<CartesianCategoriesHierarchyChip> // categories dropzone chips
                            {
                                // add 2 chips of "product category" and "product sub category" in that specific order
                                 new CartesianCategoriesHierarchyChip(uniqueName:getColumnUniqueNameFromModel(mom,"products","product category")),
                                 new CartesianCategoriesHierarchyChip(uniqueName:getColumnUniqueNameFromModel(mom,"products","product sub category"))
                            }),
                            values: new CartesianValuesDropZone(new List<CartesianValuesMeasureChip> // values dropzone chips
                            {
                                // add the given measure formula created before as the values chip
                                new CartesianValuesMeasureChip(uniqueName:formulaId.ToString())
                            }),
                            filter: new CartesianFilterDropZone(new List<CartesianFilterChip> // filter dropzone chips
                            {
                                // set filter on the customer country
                                new CartesianFilterChip(hierarchy: new CartesianFilterHierarchyChip(
                                        uniqueName:getColumnUniqueNameFromModel(mom, "customers", "country"),
                                        filterType:FilterHierarchyType.DropDownMultiSelect // OPTIONAL: set the filter type to multi-select drop down
                                        ))
                            }),
                            color: new CartesianColorDropZone(new List<CartesianColorChip>// color dropzone chips
                            {
                                // set colors by the product color
                                new CartesianColorChip(hierarchy:new CartesianColorHierarchyChip(uniqueName:getColumnUniqueNameFromModel(mom, "products", "color")))
                            })
                        )
                        ),
                    elementSelections: new List<HierarchyElementSelection> // set the element selection for this discover
                    {
                        // filter the products.color by the created custom list
                        new HierarchyElementSelection(uniqueName:getColumnUniqueNameFromModel(mom, "products", "Color"),
                        all: false, // deselect the "All Members"
                        selectionsList:new List<ElementSelectionData>
                        { // add the created list as the element selection
                            new ElementSelectionData(selectionType: ElementSelectionDataType.List,
                            uniqueNames:new List<string>{ listId.ToString() }
                            )
                        }
                        )
                    }
                    );

    Guid ret = analystApi.CreateDiscover(simpleDiscovery);// create the discover
    Console.WriteLine("Discovery id : " + ret);
}

// find a measure unique name form a model structure by the give table name and measure name
static string getMeasureUniqueNameFromModel(ModelingModel mom, string tableName, string displayName)
{
    return mom.Tables
        .Where(t => t.DisplayName.Equals(tableName, StringComparison.OrdinalIgnoreCase))// find table by name
        .First().ModelingMeasures // get all table measures
        .Where(mm => mm.DisplayName.Equals(displayName, StringComparison.OrdinalIgnoreCase)) // find measure by name
        .First().UniqueName;
}

// find a column/hierarchy unique name form a model structure by the give table name and column name
static string getColumnUniqueNameFromModel(ModelingModel mom, string tableName, string displayName)
{
    ModelingColumn? modelingColumn = mom.Tables
        .Where(t => t.DisplayName.Equals(tableName, StringComparison.OrdinalIgnoreCase))// find table by name
        .First().ModelingColumns // get all table columns
        .Where(mc => mc.DisplayName.Equals(displayName, StringComparison.OrdinalIgnoreCase)) // find column by name
        .FirstOrDefault();

    if (modelingColumn != null)// if column found
        return modelingColumn.UniqueName;

    return mom.Tables
        .Where(t => t.DisplayName.Equals(tableName, StringComparison.OrdinalIgnoreCase)) // find table by name
        .First().ModelingHierarchies // get all table hierarchies
        .Where(mh => mh.DisplayName.Equals(displayName, StringComparison.OrdinalIgnoreCase)) // find hierarchy by name
        .First().UniqueName;
    // can be searched further to hierarchy levels if needed
}